import Vue from 'vue'
import Vuex from 'vuex'
import WebSocketTools from '../websocket/WebSocketTools';

Vue.use(Vuex)

const actions={
    getChatHistory(context,{vue,uid,isGroup}){
        let proto =new vue.$protobufClass.PackageInfo();
        let data = new vue.$getChatHistory.GetChatHistory();
        data.setUid(uid); // 填充需要获取数据对象的uid
        data.setUseruid(context.state.userUid) // 自己的uid
        data.setIsgroup(isGroup)
        proto.setCallbackid(10); // 后端的处理事件id
        proto.setGetchathistory(data)
        proto=proto.serializeBinary();
        
        WebSocketTools.send(vue,proto)
    },
    updateChatUnreadMsg(context,{vue,uid,unreadmsg,isGroup}){
        // 发送请求给后端处理已读
        let proto =new vue.$protobufClass.PackageInfo();
        let data = new vue.$chatHistory.ChatHistory();
        if(isGroup){
            data.setGroupuid(uid)
        }else{
            data.setSenduseruid(uid)
        }
        proto.setChathistory(data);
        proto.setToken(localStorage.getItem("token"));
        proto.setCallbackid(9); // 后端的处理事件id
        proto=proto.serializeBinary();
        vue.$webSocketTools.send(vue,proto)

        // 给前端做已读操作
        context.state.allUnreadMsg-=unreadmsg>0?unreadmsg:0
        for(let i=0 ; i<context.state.chatList.length;i++){
            if(context.state.chatList[i].uid==uid){
                context.state.chatList[i].unreadmsg=0;
                break;
            }
        }


    }
}

const mutations={
    // 初始化内容
    HTTP_INIT_DATA(state,data){
        state.userUid=data.init.uid
        state.userName=data.init.name
        state.headImage=data.init.headimage
        state.chatList=data.init.chatlistList
        data.init.chatlistList.forEach(item => {
            state.allUnreadMsg+=item.unreadmsg
        });

    },
    // 将连接对象传给VueX
    WEB_SOCKET(state,data){
        state.socket=data
    },
    // 将添加对应回调方法并将任务id+1
    ADD_TASK(state,data){
        const currentTaskId = state.taskId; // 这样先拿出来可以保证高并发的时候不会出现竞态条件之类的问题
        state.taskMapping[currentTaskId+1]=data;
        state.taskId++;
    },
    // 删除已完成的任务
    DELETE_TASK(state,data){
        delete state.taskMapping[data]
    },
    // 是否该对象已经添加为好友或已加入群聊
    IS_ADDED(state,uid){ 
        state.friendList.forEach(item => {
            if( item.uid==uid){
                return true
            }
        });
        state.groupList.forEach(item => {
            if( item.uid==uid){
                return true
            }
        });
        return false;
    },
    // 初始化好友和群聊列表数据
    INIT_LIST_FRIEND_AND_GROUP(state,{friendList,groupList,addFriendList,addGroupList}){
        state.groupList=groupList;
        state.friendList=friendList;
        state.addFriendList=addFriendList;
        state.addGroupList=addGroupList;
        addFriendList.forEach(item=>{
            if(!item.isread){
                state.addFriendMsg++;
            }
        })
        addGroupList.forEach(item=>{
            if(!item.isread){
                state.addGroupMsg++;
            }
        })
    },
    // 修改好友或群聊的添加请求未读条数
    UPDATE_FRIEND_OR_GROUP(state,{isGroup,data}){
        if(isGroup){
            state.addGroupMsg++;
            state.addGroupList.unshift(data)
        }else{
            state.addFriendMsg++;
            state.addFriendList.unshift(data)
        }
    },
    // 清空好友或群聊的添加请求未读条数
    CLEAR_FRIEND_OR_GROUP(state,isGroup){    
        if(isGroup){
            state.addGroupMsg=0;
        }else{
            state.addFriendMsg=0;
        }
    },
    // 添加一个群对象（只用来展示，相当于热更新，后端已经有了，下次刷新页面自然会拿到）
    INSERT_ONE_GROUP_OBJECT(state,data){  
        state.groupList.unshift(data)
    },
    // 删除一个群对象
    DELET_ONE_GROUP_OBJECT(state,uid){ 
        for (let i = 0; i < state.groupList.length; i++){
            if( state.groupList[i].uid===uid){
                state.groupList.splice(i,1)
                break;
            }
        }
    },
    // 添加一个好友对象（只用来展示，相当于热更新，后端已经有了，下次刷新页面自然会拿到）
    INSERT_ONE_FRIEND_OBJECT(state,data){  
        state.friendList.unshift(data)
    },
    // 删除一个好友对象
    DELET_ONE_FRIEND_OBJECT(state,uid){  
        for (let i = 0; i < state.friendList.length; i++){
            if( state.friendList[i].uid===uid){
                state.allUnreadMsg-=state.friendList[i].unreadmsg>0?state.friendList[i].unreadmsg:0
                state.friendList.splice(i,1)
                break;
            }
        }
    },
    // 删除一个群添加请求对象
    DELET_ONE_ADD_GROUP_OBJECT(state,uid){ 
        for (let i = 0; i < state.addGroupList.length; i++){
            if( state.addGroupList[i].uid===uid){
                state.addGroupList.splice(i,1)
                state.addGroupMsg==0?0:state.addGroupMsg--;
                break;
            }
        }
    },
    // 删除一个好友添加请求对象
    DELET_ONE_ADD_FRIEND_OBJECT(state,uid){  
        for (let i = 0; i < state.addFriendList.length; i++){
            if( state.addFriendList[i].uid===uid){
                state.addFriendList.splice(i,1)
                state.addFriendMsg==0?0:state.addFriendMsg--;
                break;
            }
        }
    },
    // 更新聊天对象内容
    UPDATE_CHAT_OBJECT(state,{uid,name,headImage,isGroup,exist}){
        state.chatObjectUid=uid;
        state.chatObjectName=name;
        state.chatObjectHeadImage=headImage;
        state.chatObjectIsGroup=isGroup;
        state.chatObjectExist=exist;
    },
    // 更新主页左侧选择栏选中内容
    UPDATE_HOME_INDEX(state,index){
        state.selectedImageIndex=index;
    },
    // 初始化聊天窗口内容
    INIT_CHAT_MSG(state,data){
        state.chatMsgList=data;
    },
    // 添加一条新消息给聊天窗口
    UPDATE_CHAT_MSG(state,data){
        state.chatMsgList.push({ ...data });
    },
    // 更新消息列表的消息内容
    UPDATE_CHAT_LIST(state,chathistory){
        let notHave=true;

        for (let i = 0; i < state.chatList.length; i++){
            // 这里是考虑两种情况，当消息是好友私聊和群消息时分别有不同的判断条件
            if(((state.chatList[i].uid===chathistory.senduseruid || state.chatList[i].uid===chathistory.getuseruid)
                && chathistory.groupuid<=0)
                // 这里开始就时群的条件
                ||(chathistory.groupuid>0 && state.chatList[i].uid===chathistory.groupuid)){
                state.chatList[i].chathistory.data=chathistory.data
                state.chatList[i].chathistory.isimage=chathistory.isimage
                state.chatList[i].chathistory.sendusername=chathistory.sendusername
                notHave=false
                break;
            }
        }
        if(state.chatList.length==0 || notHave){
            // 组装给消息列表的数据
            let lastData={
                uid:0,
                headimage:'',
                name:"",
                lastdate:chathistory.date,
                chathistory:chathistory,
                unreadmsg:0,
                exist:true
            }
            if(chathistory.groupuid>0){ // 如果是群就添加群内容
                lastData.uid=chathistory.groupuid
                lastData.headimage=WebSocketTools.base64ToImage(chathistory.groupheadimage)
                lastData.name=chathistory.groupname
            }else{
                // 是好友就添加非自己的内容
                if(chathistory.senduseruid==state.userUid){
                    lastData.uid=chathistory.getuseruid
                    lastData.headimage=WebSocketTools.base64ToImage(chathistory.getuserheadimage)
                    lastData.name=chathistory.getusername
                }else if(chathistory.getuseruid==state.userUid){
                    lastData.uid=chathistory.senduseruid
                    lastData.headimage=WebSocketTools.base64ToImage(chathistory.senduserheadimage)
                    lastData.name=chathistory.sendusername
                }
            }
            
            state.chatList.unshift(lastData);
        }
    },
    // 更新消息列表的的未读消息条数
    CHAT_LIST_UNREAD_NUMBER_ADD(state,chathistory){
        for (let i = 0; i < state.chatList.length; i++){
            if(((state.chatList[i].uid===chathistory.senduseruid || state.chatList[i].uid===chathistory.getuseruid)
            && chathistory.groupuid<=0)
            // 这里开始就时群的条件
            ||(chathistory.groupuid>0 && state.chatList[i].uid===chathistory.groupuid)){
                state.chatList[i].unreadmsg++;
                state.allUnreadMsg++;
                break;
            }
        }
    },
    INIT_MESSAGE_WINDOWS(state){
        state.notInit=false; // 撤销聊天框占位图,开始聊天
    },
    INIT_MESSAGE_OLDSCROLL_HEIGHT(state){
        state.messageOldScrollHeight=0; // 重置旧值
    },
    UPDATE_MESSAGE_OLDSCROLL_HEIGHT(state,data){
        state.messageOldScrollHeight=data; // 更新旧值
    },
    // 删除一个消息对象
    DELET_ONE_CHAT_LIST_OBJECT(state,uid){  
        for (let i = 0; i < state.chatList.length; i++){
            if( state.chatList[i].uid===uid){
                state.allUnreadMsg-=state.chatList[i].unreadmsg>0?state.chatList[i].unreadmsg:0
                state.chatList.splice(i,1)
                if(state.chatObjectUid===uid){
                    state.chatObjectUid=-1
                    state.notInit=true
                }
                break;
            }
        }
    },
    SET_KEEPDOWN_REF(state,ref){
        state.keepDown=ref
    }
    
}

const state={
    keepDown:null, // 聊天窗口ref
    messageOldScrollHeight:0, // 聊天窗口用来确定是否移动视角到新消息位置的旧数据高度
    notInit:true, // 主页是否展示聊天窗口的占位图片
    selectedImageIndex:-1, // 主页面左侧选择对象下标
    chatObjectExist:null, // 聊天对象是否存在(未注销)
    chatObjectUid:-1, // 聊天对象uid
    chatObjectName:'', // 聊天对象名字
    chatObjectHeadImage:'', // 聊天对象头像
    chatObjectIsGroup:null, // 聊天对象是否为群聊
    chatMsgList:[], // 当前聊天窗口消息内容列表
    friendList:[], // 好友列表
    groupList:[], // 群列表
    allUnreadMsg:0, // 所有未读消息条数(感觉不需要他了,直接用计算属性算chatList更好)
    // 注意，这个消息列表的维护仅需要删除和插入，并且严格控制每次操作的顺序
    chatList:[], // 用户的消息列表,注意，这里只能存放proto中的ChatList对象
    addFriendMsg:0, // 所有添加好友请求条数
    addFriendList:[], // 所有添加好友请求
    addGroupMsg:0, // 所有添加你为群主的群请求条数
    addGroupList:[], // 所有添加你为群主的群请求
    userUid:-1, // 用户uid
    userName:'', // 用户昵称
    headImage:'', // 用户头像
    socket:null, // websocket连接对象
    taskId:0, // websocket的任务id
    taskMapping:{} //任务映射,通过它识别对应的websocket任务执行结果以及执行自己的回调方法 
}

export default new Vuex.Store({
    actions,
    mutations,
    state
})